package com.sumainfor.pc.market.service;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.sumainfor.common.Constants;
import com.sumainfor.common.config.RedisUtils;
import com.sumainfor.common.entity.TemplateData;
import com.sumainfor.common.util.*;
import com.sumainfor.common.utlis.*;
import com.sumainfor.common.wechat.WeChatConfig;
import com.sumainfor.common.wechat.WxConstant;
import com.sumainfor.common.wechat.WxEncodeUtil;
import com.sumainfor.common.wechat.weUtil.WXPayConstants;
import com.sumainfor.common.wechat.weUtil.WXPayUtil;
import com.sumainfor.pc.market.dao.*;
import com.sumainfor.pc.market.feign.EpcFeign.EpcFeign;
import com.sumainfor.pc.market.feign.Zfeign.ZpcEpcFeign;
import com.sumainfor.pc.market.feign.Zfeign.ZpcGmioFeign;
import com.sumainfor.pc.market.feign.ZuulFeign.ZuulFeign;
import com.sumainfor.pc.market.service.tenant.SignedProviderService;
import org.apache.commons.collections.MapUtils;
import org.apache.commons.lang.StringUtils;
import org.omg.PortableInterceptor.SYSTEM_EXCEPTION;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.transaction.interceptor.TransactionAspectSupport;
import sun.util.locale.LocaleObjectCache;

import java.awt.*;
import java.io.Serializable;
import java.math.BigDecimal;
import java.text.SimpleDateFormat;
import java.util.*;
import java.util.List;
import java.util.concurrent.locks.ReentrantLock;

/**
 *合同
 */
@Service
public class RdPactService implements Serializable {

    private ReentrantLock lock = new ReentrantLock(false);

    Logger log = LoggerFactory.getLogger(RdPactService.class);// 日志

    @Autowired
    private RdPactMapper rdPactMapper;
    @Autowired
    private RdPactSharedMapper rdPactSharedMapper;
    @Autowired
    private RdHousingInfoMapper rdHousingInfoMapper;
    @Autowired
    private RdPactConInfoMapper rdPactConInfoMapper;
    @Autowired
    private SePactMapper sePactMapper;
    @Autowired
    private SignedProviderService signedProviderService;
    @Autowired
    private ZpcGmioFeign zpcGmioFeign;
    @Autowired
    private UtilsMapper utilsMapper;
    @Autowired
    private ZpcEpcFeign zpcEpcFeign;
    @Autowired
    private RdHousingSmartMapper rdHousingSmartMapper;
    @Autowired
    private RdHousingShelfMapper rdHousingShelfMapper;
    @Autowired
    private RedisUtils redisUtils;

    @Autowired
    private RdTenantBlaMapper blaMapper;

    @Autowired
    ZuulFeign ZuulFeign;

    @Autowired
    MeterBillService meterBillService;

    @Autowired
    EpcFeign epcFeign;

    String UUID=null;

    /**
     * 查询历史签约合同记录
     */
    public List<Map<String,Object>> getPactList(Map<String,Object> params){

        return rdPactMapper.getPactList(params);
    }
    /**
     * 发起签约时查询客户已签约的合同
     */
    public List<Map<String,Object>> getPactListByTenId(Map<String,Object> params){

        return rdPactMapper.getPactListByTenId(params);
    }
    /**
     * 签约新增合同 不需要审核的
     */
    @Transactional(rollbackFor = Exception.class)
    public JsonResult addPact(Map<String,Object> params){
        JsonResult result=new JsonResult();
        System.out.println("进入签约 ");
        /**
         * 加锁操作
         */
        lock.lock();
        try{
            try {

                //获取当前时间
                Date nowTime = new Date();
                SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
                String orderDate = sdf.format(nowTime);//当前时间

                if(params.get("HouInfoId")==null || params.get("HouId")==null || params.get("ProOperaType")==null
                        || params.get("sameCityCount")==null || params.get("sThoCount")==null){
                    return  result.putFailed("参数不完整");
                }
                Map<String,Object>uuid=utilsMapper.getUUID(new HashMap<String,Object>(){{
                    put("uuid", "PaId");
                    put("database", Constants.DATA_SOURCE_TCMKT);
                    put("surface", "tcmkt_pact");
                }});
                if(uuid!=null){
                    int number=Integer.valueOf(uuid.get("uuid").toString());
                    UUID= ComUtils.getLocalTrmSeqNum("pt",number);
                }else{
                    UUID=ComUtils.getLocalTrmSeqNum("pt",0);
                }
                params.put("by", ContextUtils.getUserId());//操作人
                params.put("PaId",UUID);//合同编号
                params.put("IfAudit",0);//是否要审核（0 否 1 是）
                params.put("term", "2");// 创建端 Insert端： 1 租客端 2市场部 3 工程部   4运营部   5财务部  6总经办 7发展部
                params.put("fnc",
                        this.getClass().getSimpleName() + "." + Thread.currentThread().getStackTrace()[1].getMethodName());// 创建Function名
                ParamsCommon.commonInsertParms(params);
                JSONArray jsonArray =(JSONArray)params.get("letterList");
                params.put("Rests",jsonArray.toString());
                params.put("id",params.get("PaId"));
                log.info("params======================="+params.get("id"));
                log.info("params======================="+params.get("TenId"));


                //////////////////////////////////////////////////
                //生成电子合同必传参数
                /////////////////////////////////////////////////
                params.put("HTbianhao",params.get("PaId"));//合同编号
                params.put("HTjiafang","上海唐巢公共租赁住房运营有限公司");//出租方甲方
                //params.put("HTyifang",);//承租方乙方
               // params.put("HTdizhi",);//房屋地址
               // params.put("HTzulinqixian",);//租赁期限
                params.put("HTqishiriqi",params.get("StartTime"));//起始日期
                params.put("HTjiezhiriqi",params.get("EndTime"));//终止日期
                params.put("HTzujin",params.get("PaRearMonthPrice"));//房屋月租金
                params.put("HTzujindaxie",TransFormUtil.toChinese(params.get("PaRearMonthPrice").toString()));//月租金大写
                Integer PmthendInt = MapUtils.getInteger(params,"Pmethod");
                if (PmthendInt==0){//月付
                    params.put("HTfu",1);//支付方式付
                }else if(PmthendInt==1){//季付
                    params.put("HTfu",3);//支付方式付
                }else if(PmthendInt==2){//半年付
                    params.put("HTfu",6);//支付方式付
                }else if(PmthendInt==3){//年付
                    params.put("HTfu",12);//支付方式付
                }
                params.put("HTya",params.get("Deposit"));//支付方式押
                params.put("HTyayue",params.get("Deposit"));//租赁押金月
                Integer PaInteger = MapUtils.getInteger(params,"PaMonthPrice")* MapUtils.getInteger(params,"Deposit");
                params.put("HTtongyidingjia",PaInteger);//人民币
                params.put("HTtongyidingjiadaxie",TransFormUtil.toChinese(String.valueOf(PaInteger)));//人民币大写
                params.put("HTdianfei",params.get("EleFee").toString()+"元/度");//电费
//                params.put("HTshuifei",);//水费
//                params.put("HTranqi",);//燃气费
                params.put("HTkuandai",params.get("BroadBand"));//宽带费
                params.put("HTdianshi",0);//有限电视
                params.put("HTqita",0);//其他
                params.put("HTchuzufangjiafang","上海唐巢公共租赁住房运营有限公司");//出租房（甲方)
             //   params.put("HTdailirenjiafang","上海唐巢公共租赁住房运营有限公司");//甲方代理人
                params.put("HTqianyueriqijiafang",orderDate);//甲方签约日期
                //params.put("HTshenfengzhengyifang",);//乙方身份证
               // params.put("HTlianxidizhiyifang",);//乙方联系地址
               // params.put("HTlianxidianhuayifang",);//乙方联系电话
               // params.put("HTjinjilianxirenyifang",);//乙方紧急联系人电话
                params.put("HTqianyueriqiyifang",orderDate);//乙方签约日期


                log.info("生成电子合同前查询参数111111111111111111111");
                log.info("params"+params);
                log.info("生成电子合同前查询参数111111111111111111111");

                //调用生成电子合同的方法
                JsonResult resultTen=signedProviderService.createPact(params);
                System.out.println("JsonResult:"+resultTen);
                if(resultTen.get("errorCode").toString().equals("0")){//返回电子合同模板
//                    //调用生成账单
//                    Map<String,Object> gmioMap=new HashMap<String,Object>();
//                    gmioMap.put("WaDeposit",params.get("WaDeposit"));
//                    gmioMap.put("HouId",params.get("HouId"));
//                    gmioMap.put("HouInfoId",params.get("HouInfoId"));
//                    gmioMap.put("TenId",params.get("TenId"));
//                    gmioMap.put("payYa",params.get("payYa"));
//                    gmioMap.put("Pmethod",params.get("Pmethod"));
//                    gmioMap.put("PaId",params.get("PaId"));
//                    gmioMap.put("bottomADate",params.get("bottomADate"));
//                    gmioMap.put("monthMoney",params.get("monthMoney"));
//                    gmioMap.put("CorId",params.get("CorId"));
//                    gmioMap.put("payFu",params.get("payFu"));
//                    JsonResult gmioResult=zpcGmioFeign.addTenantBillForPact(gmioMap);
//                    System.out.println("返回参数运营部:"+gmioResult);
//                    if (!gmioResult.get("errorCode").toString().equals("0")){
//                        TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
//                        return result.putFailed("服务器繁忙");
//                    }
                    Map<String,Object> tenMap=(Map<String,Object>)resultTen.get("result");
                    params.putAll(tenMap);//把电子合同的信息保存到合同表
                    params.put("SysUserId",ContextUtils.getUserId());//合同签署人员
                    params.put("actualDeposit",params.get("PaMonthPrice"));//合同押金
                    params.put("MoviesVal",params.get("MoviesVal0"));//电表读数
                    rdPactMapper.addPact(params);//新增合同
                    //新增合租人 chekbox1 true无合租人  false 有合租人
                    if(params.get("chekbox1").toString().equals("false")) {
                        List<Map<String, Object>> list = (List<Map<String, Object>>) params.get("conList");
                        for (Map<String, Object> map : list) {
                            map.putAll(params);
                            rdPactSharedMapper.addPactShared(map);
                        }
                    }
                  /*  //房源配置组合参数
                    Map<String,Object> inMap=new HashMap<String, Object>();
                    inMap.put("PaId",params.get("PaId"));//合同编号
                    inMap.put("HouInfoId",params.get("HouInfoId"));
                    inMap.put("by", ContextUtils.getUserId());//操作人
                    inMap.put("term", "2");// 创建端 Insert端： 1 租客端 2市场部 3 工程部   4运营部   5财务部  6总经办 7发展部
                    inMap.put("fnc",
                            this.getClass().getSimpleName() + "." + Thread.currentThread().getStackTrace()[1].getMethodName());// 创建Function名
                    ParamsCommon.commonInsertParms(inMap);
                    //新增房源配置
                    System.out.println("inMap:"+inMap);
                    List<Map<String,Object>> houConList=(List<Map<String,Object>>)params.get("houConList");
                    for (Map<String,Object> map: houConList){
                        map.putAll(inMap);
                        System.out.println("Map:"+map);
                        rdPactConInfoMapper.addPactConInfo(map);
                    }*/
                    //修改房源状态为已经签约
                    Map<String,Object> map=new HashMap<String,Object>();
                    map.put("State",2);//房源状态（0 待上架 1可签约 2已签约）
                    map.put("HouInfoId",params.get("HouInfoId"));//房源详表的编号
                    map.put("HouId",params.get("HouId"));//房源主表的编号
                    map.put("ProOperaType",params.get("ProOperaType"));//房源的租赁类型
                    log.info("房源表里的合同编号:"+UUID);
                    map.put("PaId",UUID);//房源当前合同编号
                    map.put("by", ContextUtils.getUserId());//操作人
                    map.put("term", "2");// 更新端 Update端： 1 租客端 2市场部 3 工程部   4运营部   5财务部  6总经办 7发展部
                    map.put("fnc",
                            this.getClass().getSimpleName() + "." + Thread.currentThread().getStackTrace()[1].getMethodName());// 创建Function名
                    ParamsCommon.commonUpdateParms(map);
                    //租赁类型（1.合租 2.整租）
                    if (params.get("ProOperaType").toString().equals("1")){
                        map.put("ifHouInfoId","1");
                    }else{
                        map.put("ifHouId","1");
                    }
                    Integer houCount=rdHousingInfoMapper.updateHousingStateHouInfo(map);
                    //如果是签约的房子是合租的房源就把整租的房源下架
                    map.put("State",0);//房源状态（0 待上架 1可签约 2已签约 ）
                    Integer houCount2=0;;
                    if (params.get("ProOperaType").toString().equals("1")){
                        houCount2=rdHousingInfoMapper.updateHouStateHouInfo(map);
                    }else{
                        houCount2=1;
                    }
                    if (houCount>0 && houCount2>0){
                        //修改内部房源在第三方平台房源状态
                        Integer sameCityCount=(Integer)params.get("sameCityCount");//58 是否已经发布
                        Integer sThoCount=(Integer)params.get("sThoCount");//该房间的整租房源是否在58发布过
                        //58 第三方上架状态 0 待上架 1可签约 2已签约
                        if (sameCityCount>0 && params.get("stPrimaryStatus").toString().equals("1")){
                            //修改第三房源为下架
                            params.put("PrimaryStatus","0");//第三方上架状态 0 待上架 1可签约 2已签约
                            params.put("SheId",params.get("stSheId"));//58 第三方上架表主键
                            Integer shelfCount=rdHousingShelfMapper.upRdHs(params);
                            if (shelfCount!=null && shelfCount>0){
                                //如果58被选中就让房源在58那里下架s
                                Map<String,Object> dataMap=new HashMap<String,Object>();
                                dataMap.put("appId",InteSameCityConfig.APPID_TEST);
                                dataMap.put("houseId",params.get("stPrimaryKey"));//内部房源在58平台的唯一标识
                                dataMap.put("status","4000");//房屋修改状态，枚举值 3000 上线 4000:下线 5000:已出租
                                //请求体
                                Map<String,String> maphead=new HashMap<String,String>();
                                //组装请求接口的map类型参数 转成json 然后生成加密字符串
                                String rsaString=ThirdRSACoder.encrypt(JSON.toJSONString(dataMap),InteSameCityConfig.PRIVATE_KEY);
                                log.info("rsaString:"+rsaString);
                                log.info("rsaString2:"+ThirdRSACoder.decrypt(rsaString,InteSameCityConfig.PUBLIIC_KEY));
                                maphead.put("data",rsaString);
                                //请求58的修改房源状态接口
                                Map<String,Object> sameShellResult=InteSameCityUtil.api_house_status_modify(maphead);
                                //租赁类型（1.合租 2.整租）
                                if (params.get("ProOperaType").toString().equals("1") && sThoCount >0 && params.get("sThoPrimaryStatus").equals("1")){
                                    dataMap.put("houseId",params.get("sThoPrimaryKey"));//内部房源在58的唯一标识
                                    rsaString=ThirdRSACoder.encrypt(JSON.toJSONString(dataMap),InteSameCityConfig.PRIVATE_KEY);
                                    maphead.put("data",rsaString);
                                    log.info("rsaString:"+rsaString);
                                    log.info("rsaString2:"+ThirdRSACoder.decrypt(rsaString,InteSameCityConfig.PUBLIIC_KEY));
                                    Map<String,Object> sThoResult=InteSameCityUtil.api_house_status_modify(maphead);
                                    if (sThoResult.get("code").toString().equals("0")){
                                        result.putSuccess("下架成功");
                                    }else{
                                        TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
                                        result.putFailed("服务器繁忙");
                                    }
                                }
                                if (sameShellResult.get("code").toString().equals("0")){
                                    result.putSuccess("下架成功");
                                }else{
                                    result.putFailed("服务器繁忙");
                                }
                            }
                        }
                        //推送微信模板
                        String touser=params.get("openid").toString();//租客的openid
                        Map<String, TemplateData> param = new HashMap<>();
                        param.put("first", new TemplateData("唐巢公寓温馨提示：尊敬的租客，您与我司签的租赁合同已签约成功。请您确认信息是否正确？如有异议，请联系您的租赁顾问人员为您服务。\n", "#4876FF"));
                        param.put("keyword1", new TemplateData(params.get("payYaMoney").toString()+"元", "#4876FF"));
                        param.put("keyword2", new TemplateData(params.get("payFu")+"个月", "#4876FF"));
                        BigDecimal sumMoney=new BigDecimal(params.get("payYaMoney").toString()).multiply(new BigDecimal(params.get("payFu").toString()));//租金合计
                        param.put("keyword3", new TemplateData(sumMoney+"元", "#4876FF"));
                        String PmethodName="月付";
                        if (String.valueOf(params.get("Pmethod")).equals("0")){
                            PmethodName="月付";
                        }else if (String.valueOf(params.get("Pmethod")).equals("1")){
                            PmethodName="季付";
                        }else if (String.valueOf(params.get("Pmethod")).equals("2")){
                            PmethodName="半年付";
                        }else if (String.valueOf(params.get("Pmethod")).equals("3")){
                            PmethodName="年付";
                        }
                        param.put("keyword4", new TemplateData(PmethodName, "#4876FF"));
                        log.info("param:"+net.sf.json.JSONObject.fromObject(param));
                        Jsapi_ticketUtil.sendTemplate(touser,WeChatConfig.TEMPLATE_ID,"http://www.4006269069.net/#/staySigning?pactId="+params.get("PaId"),"#4876FF", net.sf.json.JSONObject.fromObject(param));
                        result.putSuccess("合同创建成功");


                        //签约成功通知
                        CustomMap data = CustomMap.create("MeType", 3)
                                .put("Title", "签约成功")
                                .put("Content", HtmlUtil.stringToHTML(String.format("恭喜！您的合同（%s） 签约成功，继续加油吧！；",UUID), "", Color.blue))
                                .put("by", ContextUtils.getUserId())
                                .put("term", 2);
                        ZuulFeign.AddMessage(data);



                        Map<String,Object> MeterMapper = new HashMap<>();
                        MeterMapper.put("ProOperaType",params.get("ProOperaType"));
                        MeterMapper.put("HouInfoId",params.get("HouInfoId"));
                        MeterMapper.put("smartMeterMap",params.get("smartMeterMap"));
                        MeterMapper.put("value",params.get("EleFee"));//签约时的单价
                       meterBillService.GetMeterBill(MeterMapper);//签约修改智能电表



                    }else{
                        result.putFailed("服务器繁忙");
                        TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
                    }

                }else{//如果电子合同返回的状态码异常就不去新增合同主表
                    result.putFailed("合同模板创建异常");
                    TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
                }
            } catch (Exception e) {
                e.printStackTrace();
                TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
                result.putFailed("服务器繁忙");
            }
        }
        finally {
            lock.unlock();
        }
        return result;
    }
    /**
     * 签约新增合同 要审核
     */
    @Transactional(rollbackFor = Exception.class)
    public JsonResult addPactExamine(Map<String,Object> params){
        JsonResult result=new JsonResult();
        /**
         * 加锁操作
         */
        lock.lock();
        try{
            try {
                //合同编号
                Map<String,Object>uuid=utilsMapper.getUUID(new HashMap<String,Object>(){{
                    put("uuid", "PaId");
                    put("database", Constants.DATA_SOURCE_TCMKT);
                    put("surface", "tcmkt_pact");
                }});
                if(uuid!=null){
                    int number=Integer.valueOf(uuid.get("uuid").toString());
                    UUID= ComUtils.getLocalTrmSeqNum("pt",number);
                }else{
                    UUID=ComUtils.getLocalTrmSeqNum("pt",0);
                }
                params.put("by", ContextUtils.getUserId());//操作人
                params.put("PaId",UUID);
                params.put("IfAudit",1);//是否要审核（0 否 1 是）
                params.put("term", "2");// 创建端 Insert端： 1 租客端 2市场部 3 工程部   4运营部   5财务部  6总经办 7发展部
                params.put("fnc",
                        this.getClass().getSimpleName() + "." + Thread.currentThread().getStackTrace()[1].getMethodName());// 创建Function名
                ParamsCommon.commonInsertParms(params);
                //新增一条账单/违约金异常记录
                params.put("BillType","1");//账单异常分类   1.房租（合同）   2.退租账单
                params.put("Source",params.get("PaId"));//账单异常来源编号（那一笔账单异常）
                params.put("MiId",params.get("SeId"));//服务中心编号
                params.put("BeforeAbnormal",params.get("PaRearMonthPrice"));//异常前金额
                params.put("RearAbnormal",params.get("PaActMonthPrice"));//异常后金额
                JsonResult gmioResult=zpcGmioFeign.addSeBill(params);
                if (!gmioResult.get("errorCode").toString().equals("0")){
                    log.info("运营部服务器繁忙");
                    return result.putFailed("服务器繁忙");
                }
                JSONArray jsonArray =(JSONArray)params.get("letterList");
                params.put("Rests",jsonArray.toString());
                params.put("SysUserId",ContextUtils.getUserId());//合同签署人员
                params.put("id",params.get("PaId"));
                log.info("params======================="+params.get("id"));
                log.info("params======================="+params.get("TenId"));
                params.put("actualDeposit",params.get("PaMonthPrice"));//合同押金
                rdPactMapper.addPact(params);//新增合同
                if(uuid!=null){
                    int number=Integer.valueOf(uuid.get("uuid").toString());
                    UUID= ComUtils.getLocalTrmSeqNum("pte",number);
                }else{
                    UUID=ComUtils.getLocalTrmSeqNum("pte",0);
                }
                params.put("PactTemId",UUID);//合同模板编号
                sePactMapper.addPactTemplate(params);//新增合同模板

                List<Map<String,Object>> list=(List<Map<String,Object>>)params.get("conList");
                for (Map<String,Object> map:list) {
                    map.putAll(params);
                    rdPactSharedMapper.addPactShared(map);
                }

            /*    //房源配置组合参数
                Map<String,Object> inMap=new HashMap<String, Object>();
                inMap.put("PaId",params.get("PaId"));//合同编号
                inMap.put("HouInfoId",params.get("HouInfoId"));
                inMap.put("by", ContextUtils.getUserId());//操作人
                inMap.put("term", "2");// 创建端 Insert端： 1 租客端 2市场部 3 工程部   4运营部   5财务部  6总经办 7发展部
                inMap.put("fnc",
                        this.getClass().getSimpleName() + "." + Thread.currentThread().getStackTrace()[1].getMethodName());// 创建Function名
                ParamsCommon.commonInsertParms(inMap);
                //新增房源配置
                System.out.println("inMap:"+inMap);
                List<Map<String,Object>> houConList=(List<Map<String,Object>>)params.get("houConList");
                for (Map<String,Object> map: houConList){
                    map.putAll(inMap);
                    System.out.println("Map:"+map);
                    rdPactConInfoMapper.addPactConInfo(map);
                }*/

                //新的特价房源审核通知
                CustomMap data = CustomMap.create("MeType", 4)
                        .put("Title", "新的特价房源审核")
                        .put("Content", HtmlUtil.stringToHTML(String.format("注意！您有特价签约价的房源（%s）需要审核！；",UUID), UUID, Color.blue))
                        .put("by", ContextUtils.getUserId())
                        .put("IfJump", 1)
                        .put("Neturl", "sys-ServiceManager/contractExamin")
                        .put("term", 2);
                ZuulFeign.AddMessage(data);


                //加上修改单价的操作
                Map<String,Object> MeterMapper = new HashMap<>();
                MeterMapper.put("ProOperaType",params.get("ProOperaType"));
                MeterMapper.put("HouInfoId",params.get("HouInfoId"));
                MeterMapper.put("smartMeterMap",params.get("smartMeterMap"));
                MeterMapper.put("value",params.get("EleFee"));//签约时的单价
                meterBillService.GetMeterBill(MeterMapper);//签约修改智能电表




                result.putSuccess("操作成功");
            } catch (Exception e) {
                e.printStackTrace();
                TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
            }
        }
        finally {
            lock.unlock();
        }
        return result;
    }

    /**
     * 查询我的签约列表
     */
    public List<Map<String,Object>> getPactListById(Map<String,Object> params){
        return rdPactMapper.getPactListById(params);
    }
    /**
     * 查询我的签约列表总数
     */
    public Integer getPactListCountById(Map<String,Object> params){
        return rdPactMapper.getPactListCountById(params);
    }
    /**
     * 运营部服务管家查询账单中心的房源信息
     */
    public List<Map<String,Object>> getHoPactList(Map<String,Object> params){
        return rdPactMapper.getHoPactList(params);
    }
    /**
     * 运营部服务管家查询房屋配置变更列表
     */
    public List<Map<String,Object>> getHouConPactList(Map<String,Object> params){
        return rdPactMapper.getHouConPactList(params);
    }
    /**
     * 运营部服务管家查询房屋配置变更列表总数
     */
    public Integer getHouConPactListCount(Map<String,Object> params){
        return rdPactMapper.getHouConPactListCount(params);
    }
    /**
     *租赁顾问输入房源详表编号的时候查询已经签约合同水燃收费标准
     */
    public Map<String,Object> getWgMeter(Map<String,Object> params){
        return  rdPactMapper.getWgMeter(params);
    }
    /**
     *运营部服务管家退租的时候根据房源编号和合同开始时间查询入住期间是否有新租客入住
     */
    public List<Map<String,Object>> getPactByTimeHouId(Map<String,Object> params){
        List<Map<String,Object>> list=rdPactMapper.getPactByTimeHouId(params);
        if (list==null){
            list=new ArrayList<Map<String,Object>>();
        }
        return  list;
    }
    /**
     * 运营部服务管家查询当前租客入住之前的户数
     */
    public Integer getPactByTimeHouIdCount(Map<String,Object> params){
        return rdPactMapper.getPactByTimeHouIdCount(params);
    }
    /**
     *服务秘书水电燃账单审核通过后修改合同 水单押金支付完成 电子合同支付状态
     */
    @Transactional(rollbackFor = Exception.class)
    public JsonResult updatePactForSe(Map<String,Object> params){
        //运营部 服务秘书审核账单的时候根据合同编号查询合同的房租是否已经缴付费
        JsonResult result=new JsonResult();
        Boolean ifInteDeviceBee=false;//true 有蜂电智能电表 false 无蜂电智能电表
        List<String> inteDeviceBeeList=new ArrayList<String>();//保存 蜂电智能设备编号
        Map<String,Object> map=rdPactMapper.getRentStatus(params);
        if (map==null){
            return  result.put("服务器繁忙");
        }
        System.out.println("map:"+map);
        if (map.get("ProOperaType").toString().equals("1")){//租赁类型（1.合租 2.整租）
            map.put("iFHouInfoId","1");
        }else{
            map.put("iFHouId","1");
        }
        //去工程部查询该租客签约房源的智能设备信息
        JsonResult zpcResult=zpcEpcFeign.getHoSeInteConList(map);
        System.out.println("工程部查询到的数据:"+zpcResult);
        if (!zpcResult.get("errorCode").toString().equals("0")){
            return result.putFailed("服务器繁忙");
        }
        List<Map<String,Object>> inteList=(List<Map<String,Object>>)zpcResult.get("result");
        System.out.println("查询到的数据inteList="+inteList);
        //支付方式 （0月付 1 季付 2 半年付 3年付）
        String pmethod=String.valueOf(map.get("Pmethod"));
        Integer payCount=1;//首期支付几个月的房租
        if (pmethod.equals("0")){//月付
            payCount=1;
        }else if(pmethod.equals("1")){//季付
            payCount=3;
        }else if(pmethod.equals("2")){//半年付
            payCount=6;
        }else if(pmethod.equals("3")){//年付
            payCount=12;
        }

        //智能设备组装参数
        Map<String,Object> InteMap=new HashMap<String,Object>();
        InteMap.put("HouId",map.get("HouId"));//房源编号
        InteMap.put("TenId",map.get("TenId"));//租客编号
        InteMap.put("startDate",map.get("StartTime"));//钥匙生效时间
        InteMap.put("endDate",map.get("EndTime"));//钥匙失效时间
        InteMap.put("by", ContextUtils.getUserId());//操作人
        InteMap.put("term", "4");// 创建端 Insert端： 1 租客端 2市场部 3 工程部   4运营部   5财务部  6总经办 7发展部
        InteMap.put("fnc",
                this.getClass().getSimpleName() + "." + Thread.currentThread().getStackTrace()[1].getMethodName());// 创建Function名
        ParamsCommon.commonInsertParms(InteMap);
        for(Map<String,Object> inteMap: inteList){
            //智能设备供应商     0.蜂电   1.大华   2.科技侠   3.果加
            if (inteMap.get("Intelligent")!=null){
                InteMap.put("SmaId", UUIDUtils.generateShortUuid());//智能设备密码记录UUID
                InteMap.put("SmaType",inteMap.get("Intelligent"));//智能设备供应商     2.科技侠   3.果加
                InteMap.put("Identifier",inteMap.get("Identifier"));//智能设备识别码
                InteMap.put("CodeType",2);//密码类型   1.键盘密码  2.蓝牙密码
                InteMap.put("HouConId",inteMap.get("HouConId"));//房源配置详表编号
                InteMap.put("HouConType",inteMap.get("HouConType"));//房源配置类型 1公共区域 2房间 3整租
                InteMap.put("OperTime",InteMap.get("instm"));//操作时间
                if (inteMap.get("Intelligent").toString().equals("2")){
                    String DeviceLockToken=redisUtils.get("DeviceLockToken");
                    //如果获取不到就重新登录
                    if (DeviceLockToken==null){
                        Map<String,Object> tokenMap=new HashMap<String, Object>();
                        tokenMap.put("client_id",InteDeviceLockConfig.CLIENT_ID);
                        tokenMap.put("client_secret",InteDeviceLockConfig.CLIENT_SECRET);
                        tokenMap.put("grant_type",InteDeviceLockConfig.GRANT_TYPE_PASSWORD);
                        tokenMap.put("username",InteDeviceLockConfig.USERNAME);
                        tokenMap.put("password",InteDeviceLockConfig.PASSWORD);
                        tokenMap.put("redirect_uri",InteDeviceLockConfig.REDIRECT_URL);
                        System.out.println("请求科技侠的参数:"+tokenMap);
                        tokenMap=InteDeviceLockUtil.oauth2Token(tokenMap);
                        if (tokenMap.get("access_token")!=null){
                            DeviceLockToken=tokenMap.get("access_token").toString();
                            //token存到redis中
                            redisUtils.set("DeviceLockToken",DeviceLockToken,Long.valueOf(tokenMap.get("expires_in").toString()));
                        }else{
                            return result.putFailed("token获取失败");
                        }
                    }
                    Map<String,Object> deviceLockMap=new HashMap<String, Object>();
                    deviceLockMap.put("clientId", InteDeviceLockConfig.CLIENT_ID);
                    deviceLockMap.put("accessToken", DeviceLockToken);//科技侠访问令牌
                    //智能设备编码
                    deviceLockMap.put("lockId", inteMap.get("Identifier"));
                    //用户
                    deviceLockMap.put("receiverUsername",map.get("TenMode"));
                    //钥匙有效时间
//                    deviceLockMap.put("startDate",InteDeviceLockUtil.getTimeSign(map.get("StartTime").toString(),"yyyy-MM-dd HH:mm:ss"));
                    deviceLockMap.put("startDate",InteDeviceLockUtil.getTimeSign(DateUtils.format(DateUtils.addDateMonths( DateUtils.stringToDate(map.get("StartTime").toString(),"yyyy-MM-dd"),0))+InteDeviceLockConfig.LOCK_TIME_START,"yyyy-MM-dd HH:mm:ss"));
                    //钥匙失效时间(按照用户支付首期房租几个月就发几个月的有效期钥匙)
                    deviceLockMap.put("endDate",InteDeviceLockUtil.getTimeSign(DateUtils.format(DateUtils.addDateMonths( DateUtils.stringToDate(map.get("StartTime").toString(),"yyyy-MM-dd"),payCount))+InteDeviceLockConfig.LOCK_TIME_END,"yyyy-MM-dd HH:mm:ss"));
                    //当前时间
                    deviceLockMap.put("date",InteDeviceLockUtil.getTimeSign());
                    //1 发送钥匙时候如果发现用户没有注册过科技侠就自动创建用户
                    deviceLockMap.put("createUser","1");
                    System.out.println("deviceLockMap："+deviceLockMap);

                    Map<String,Object> mapResult=InteDeviceLockUtil.keySend(deviceLockMap);
                    System.out.println("钥匙返回的参数:"+mapResult);
                    System.out.println("InteMap1:"+InteMap);
                    if (mapResult.get("errcode")!=null && mapResult.get("errcode").toString().equals("0")){
                        InteMap.put("CodeId",mapResult.get("keyId"));//密码ID
                        InteMap.put("Operator",ContextUtils.getUserId());
                    }else{
                        TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
                        return  result.putFailed(mapResult.get("errmsg").toString());
                    }
                }else if (inteMap.get("Intelligent").toString().equals("3")){//果加门锁
                    String GuoJiaToken=redisUtils.get("GuoJiaToken");
                    //如果获取不到就重新登录
                    if (GuoJiaToken==null){
                        Map<String,Object> guoJiaMap=new HashMap<String, Object>();
                        guoJiaMap.put("s_id",InteGuoJiaUtil.getSid());
                        guoJiaMap.put("version","1");
                        com.alibaba.fastjson.JSONObject bodyJson=new com.alibaba.fastjson.JSONObject();
                        //key
                        DESEncrypt desPlus2 = new DESEncrypt(InteGuoJiaConfig.DES_KEY);
                        //密码
                        bodyJson.put("account",InteGuoJiaConfig.ACCOUNT);
                        bodyJson.put("password",desPlus2.encrypt(InteGuoJiaConfig.PASSWORD));
                        guoJiaMap=InteGuoJiaUtil.login(guoJiaMap,bodyJson);
                        if (guoJiaMap.get("rlt_code") !=null && guoJiaMap.get("rlt_code").toString().equals("HH0000")){//HH0000 、成功
                            //返回的token数据
                            Map<String,Object>dataMap=(Map<String,Object>)guoJiaMap.get("data");
                            GuoJiaToken=dataMap.get("access_token").toString();
                            //token存到redis中
                            redisUtils.set("GuoJiaToken",GuoJiaToken,Long.valueOf(dataMap.get("expires_second").toString()));
                        }else{
                            return result.putFailed("token获取失败");
                        }
                    }
                    /*发送果加的门锁钥匙*/
                    Map<String,Object> headParams=new HashMap<String, Object>();
                    headParams.put("s_id",InteGuoJiaUtil.getSid());
                    headParams.put("version","1");
                    headParams.put("access_token",GuoJiaToken);
                    JSONObject bodyJson=new JSONObject();
                    bodyJson.put("operate_pwd_auth","N");//是否允许操作密码 Y 允许 N 不允许
                    bodyJson.put("set_custom_pwd","N");//是否允许设置自定义密码 Y 允许 N 不允许智能是否允许设置自定义密码 Y 允许 N 不允许
                    bodyJson.put("lock_no",inteMap.get("Identifier"));//智能门锁的设备编号
                    bodyJson.put("mobile",map.get("TenMode"));//用户手机号
//                    bodyJson.put("auth_time_start",InteDeviceLockUtil.getTimeSign(map.get("StartTime").toString(),"yyyy-MM-dd HH:mm:ss"));//有效期开始时间
//                    bodyJson.put("auth_time_end",InteDeviceLockUtil.getTimeSign(DateUtils.format(DateUtils.addDateMonths( DateUtils.stringToDate(map.get("StartTime").toString(),"yyyy-MM-dd HH:mm:ss"),payCount))+InteDeviceLockConfig.LOCK_TIME,"yyyy-MM-dd HH:mm:ss"));//有效期结束时间
                    bodyJson.put("auth_time_start",InteDeviceLockUtil.getTimeSign(DateUtils.format(DateUtils.addDateMonths( DateUtils.stringToDate(map.get("StartTime").toString(),"yyyy-MM-dd"),0))+InteDeviceLockConfig.LOCK_TIME_START,"yyyy-MM-dd HH:mm:ss"));
//                    bodyJson.put("auth_time_end",InteDeviceLockUtil.getTimeSign(map.get("EndTime").toString(),"yyyy-MM-dd HH:mm:ss"));//有效期结束时间
                    bodyJson.put("auth_time_end",InteDeviceLockUtil.getTimeSign(DateUtils.format(DateUtils.addDateMonths( DateUtils.stringToDate(map.get("StartTime").toString(),"yyyy-MM-dd"),payCount))+InteDeviceLockConfig.LOCK_TIME_END,"yyyy-MM-dd HH:mm:ss"));
                    log.info("果加发钥匙:"+bodyJson);
                    Map<String,Object> guoJiaResult=InteGuoJiaUtil.lockAuth(headParams,bodyJson);
                    if (guoJiaResult.get("rlt_code") !=null && guoJiaResult.get("rlt_code").toString().equals("HH0000")){//HH0000 、成功
                        InteMap.put("CodeId",inteMap.get("Identifier"));//钥匙的编码就存智能设备编码
                        InteMap.put("Code",map.get("TenMode"));//果加的密码就存租客手机号
                    }else{
                        return result.putFailed(guoJiaResult.get("rlt_msg").toString());
                    }
                }





                //HouConType 1公共区域 2房间 3整租(蜂电智能电表入住不需要操作公共区域的智能电表所以不保存公区的智能设备编号)
                else if(inteMap.get("Intelligent").toString().equals("0") && inteMap.get("HouConType").toString().equals("2")){//蜂电
                    ifInteDeviceBee=true;
                    inteDeviceBeeList.add(inteMap.get("Identifier").toString());
                }
                //新增发送密钥的记录(只保存钥匙的记录)
                System.out.println("InteMap2:"+InteMap);
                if (inteMap.get("Intelligent").toString().equals("2") || inteMap.get("Intelligent").toString().equals("3")){
                    Integer smart=rdHousingSmartMapper.addRdHouSmart(InteMap);
                    if(smart<=0){
                        TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
                        return result.put("服务器繁忙");
                    }
                }

            }

        }

  if(inteList.size()>0&&inteList!=null) {
      //没有用他的逻辑,将本次智能门锁发的钥匙保存到合同表里面
      StringBuffer IntelligentRoomBuffer = new StringBuffer();
      Integer IntelligentType = new Integer("0");
      for (Map<String, Object> map4 : inteList) {//测试map,保存本次签约门锁的密码
          if (MapUtils.getString(map4, "CodeId") != null || !MapUtils.getString(map4, "CodeId").equals("")) {
              IntelligentRoomBuffer.append(MapUtils.getString(map4, "Identifier")).append(":").append(MapUtils.getString(map4, "CodeId")).append(",");
              IntelligentType = MapUtils.getInteger(map4, "Intelligent");//智能门锁类型 2科技侠 3果加
          }
      }

       Map<String, Object> MenSuoMap = new HashMap<>();
      MenSuoMap.put("PaId",params.get("PaId"));
      MenSuoMap.put("IntelligentType",IntelligentType);
      MenSuoMap.put("IntelligentRoom",IntelligentRoomBuffer.toString());
      Integer ceshi1 = rdPactMapper.updatePact(MenSuoMap);
          if (ceshi1<=0){
              TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
              return result.put("服务器繁忙");
          }

  }

        params.put("by", ContextUtils.getUserId());//操作人
        params.put("Hydropower",2);//水电押金   支付状态   0不需要支付   1.待支付   2支付完成    3待审核
        params.put("term", "4");// 创建端 Insert端： 1 租客端 2市场部 3 工程部   4运营部   5财务部  6总经办 7发展部
        params.put("fnc",
                this.getClass().getSimpleName() + "." + Thread.currentThread().getStackTrace()[1].getMethodName());// 创建Function名
        ParamsCommon.commonInsertParms(params);
        //RentStatus 房租/押金     支付状态   0不需要支付   1.待支付   2支付完成
        if (map.get("RentStatus").toString().equals("2")){
            params.put("IfFlowPay", 2);//电子合同是否支付     0无状态   1已完成未支付   \n2已完成已支付
            Integer count2=0;
            //如果有换房信息 0 没有换房合同 1 有换房合同
            if (params.get("TradeType")!=null && params.get("TradeType").toString().equals("1")){
                //房源状态变为入住的时候修改发起换房的合同为换房成功
                params.put("Trade",1);//换房申请状态   0无状态   1.换房成功   2.换房失败
                params.put("TradeId",map.get("TradeId"));//原转租合同编号
                count2=rdPactMapper.updatePactTrade(params);
                if (count2<=0){
                    TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
                    return result.put("服务器繁忙");
                }
            }
            //转租接盘侠   0无状态  1.唐巢   2.租客自家人 如果不为0 说明是转租房源
            if (params.get("PickUp")!=null && !params.get("PickUp").toString().equals("0") && !params.get("PickUp").toString().equals("")){
                params.put("PickId",map.get("PickId"));//原转租合同编号
                count2=rdPactMapper.updatePactPick(params);
                if (count2<=0){
                    TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
                    return result.put("服务器繁忙");
                }
            }
        }
        //修改该合同信息
        Integer count=rdPactMapper.updatePactForSe(params);
        if (count>0){
//            System.out.println("ifInteDeviceBee:"+ifInteDeviceBee);
//            System.out.println("inteDeviceBeeList:"+inteDeviceBeeList);
//            if (ifInteDeviceBee){ //ifInteDeviceBee true 有蜂电电表 false 没有蜂电电表
//                String InteDeviceBeeToken=redisUtils.get("InteDeviceBeeToken");
//                //如果获取不到就重新登录
//                if (InteDeviceBeeToken==null) {
//                    Map<String, Object> tokenMap = new HashMap<String, Object>();
//                    tokenMap.put("version","0116010101");//版本号 默认 0116010101
//                    tokenMap.put("appid",InteDeviceBeeConfig.APP_ID);
//                    tokenMap=InteDeviceBeeUtil.userLogin(InteDeviceBeeConfig.USERID, InteDeviceBeeConfig.PASS,tokenMap);
//                    if (tokenMap.get("Code").toString().equals("0")) {
//                        InteDeviceBeeToken = tokenMap.get("Expand").toString();
//                        //token存到redis中 有效时长一个小时
//                        redisUtils.set("InteDeviceBeeToken", InteDeviceBeeToken,3600);
//                    } else {
//                        return result.putFailed("token获取失败");
//                    }
//                }
//                //查询智能电表的UUID集合
//                Map<String,Object> pcodeParams=new HashMap<String, Object>();
//                pcodeParams.put("uid",InteDeviceBeeConfig.UID);
//                pcodeParams.put("token",InteDeviceBeeToken);
//                //查询各个房间的智能电表的UUID
//                Map<String,Object> pcodeMap=InteDeviceBeeUtil.deviceAmmeterPcode(inteDeviceBeeList,pcodeParams);
//                List<Map<String,Object>> pcodeList=(List<Map<String,Object>>)pcodeMap.get("Data");
//                List<String> beeUuidList=new ArrayList<String>();//保存智能设备的UUID
//                for (Map<String,Object> pMap: pcodeList){
//                    beeUuidList.add(pMap.get("Uuid").toString());
//                }
//                if (map.get("ProOperaType").toString().equals("1")) {//租赁类型（1.合租 2.整租）
//                    for (int i=0;i<beeUuidList.size();i++){
//                        Map<String,Object> roomMap=new HashMap<String,Object>();
//                        roomMap.put("uid",InteDeviceBeeConfig.UID);
//                        roomMap.put("token",InteDeviceBeeToken);
//                        JSONObject bodyJson=new JSONObject();
//                        bodyJson.put("name","123");// 必传 不必真实信息
//                        bodyJson.put("phone","123");//必传 不必真实信息
//                        bodyJson.put("checkingdate","15722021");
//                        bodyJson.put("checkoutdate","15722021");
////                bodyJson.put("staymode",0);入住方式，长租0，短租1
//                        //修改房间电表为入住状态
//                        InteDeviceBeeUtil.deviceAmmeterStayroom(beeUuidList.get(i),roomMap,bodyJson);
//                    }
//                }else if (map.get("ProOperaType").toString().equals("2")){
//                    for (int i=0;i<beeUuidList.size();i++){
//                        //智能设备UUID  模式0是后付费，1是预付费 请求头部信息
//                        //修改房间电表的付费模式
//                        InteDeviceBeeUtil.deviceAmmeterPaymode(beeUuidList.get(i),"0",pcodeParams);
//                    }
//                }
//        }
            //当合同信息修改成功的时候去请求
            result.putSuccess("操作成功");
        }else{
            result.putFailed("服务器繁忙");
            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
        }
        return result;
    }
    /**
     *服务秘书水电燃账单审核通过后修改合同 水单押金支付完成 电子合同支付状态
     */
    @Transactional(rollbackFor = Exception.class)
    public JsonResult updatePactForSeNo(Map<String,Object> params){
        //运营部 服务秘书审核账单的时候根据合同编号查询合同的房租是否已经缴付费
        JsonResult result=new JsonResult();
        params.put("by", ContextUtils.getUserId());//操作人
        params.put("Hydropower",1);//水电押金   支付状态   0不需要支付   1.待支付   2支付完成    3待审核
        params.put("term", "4");// 创建端 Insert端： 1 租客端 2市场部 3 工程部   4运营部   5财务部  6总经办 7发展部
        params.put("fnc",
                this.getClass().getSimpleName() + "." + Thread.currentThread().getStackTrace()[1].getMethodName());// 创建Function名
        ParamsCommon.commonInsertParms(params);
        Integer count=rdPactMapper.updatePactForSe(params);
        if (count>0){
            result.putSuccess("操作成功");
        }else{
            result.putFailed("服务器繁忙");
            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
        }
        return result;
    }
    /**
     * 租客续签合同
     */
    @Transactional(rollbackFor = Exception.class)
    public JsonResult addRerentPact(Map<String,Object> params){
        JsonResult result=new JsonResult();
        /**
         * 加锁操作
         */
        lock.lock();
        try{
            try {
                //获取当前时间
                Date nowTime = new Date();
                SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
                String orderDate = sdf.format(nowTime);//当前时间





                System.out.println("续签参数:"+params);
                if(params.get("PaId")==null || params.get("openid")==null  || params.get("TenId")==null
                        || params.get("HouInfoId")==null || params.get("actualDeposit")==null || params.get("Deposit")==null
                        || params.get("Firstmonth")==null || params.get("priceQian")==null || params.get("priceHou")==null
                        || params.get("IsWater")==null || params.get("IsGas")==null){
                    return  result.putFailed("参数不完整");
                }
                //取出tenId, 查询租客是否是黑名单租客
                String tenId = (String) params.get("TenId");
                Integer blackOrNotByTenId = blaMapper.getIsBlackOrNotByTenId(tenId);
                //如果该租客是黑名单租客, 直接返回, 不能发起签约
                if (blackOrNotByTenId > 0) {
                    result.putSuccess("黑名单租客不能发起续签");
                    return result;
                }

                //参数名转换
//                params.put("PaRearMonthPrice",params.get("priceHou"));
//                params.put("PaActMonthPrice",params.get("priceHou"));   //账单金额
//                params.put("BillMonthPrice",params.get("priceQian"));   //平均金额

                params.put("PaRearMonthPrice",params.get("priceQian"));
                params.put("PaActMonthPrice",params.get("priceQian"));   //平均金额
                params.put("BillMonthPrice",params.get("priceHou"));   //账单金额

                params.put("PaMonthPrice",params.get("UnifiedPricing"));//房源定价
                //房屋押金
                BigDecimal actualDeposit=new BigDecimal(params.get("actualDeposit").toString());
                if (!params.get("Deposit").toString().equals("0")){
                    //后台存每月的房屋押金(合计押金除以押金的月数)
                    actualDeposit=actualDeposit.divide(new BigDecimal(params.get("Deposit").toString()),0);
                }
                Map<String,Object> pactMap=new HashMap<String,Object>();//原合同关联续签合同编号
                pactMap.put("PaId",params.get("PaId"));//
                //根据房源详表编号查询房源的信息
                Map<String,Object>houMap=rdHousingInfoMapper.getWxHousingList(params);
                if (houMap!=null){
                    params.putAll(houMap);
                }else{
                    return result.putFailed("房源参数不正确");
                }
                //合同编号
                String UUID="";
                Map<String,Object>uuid=utilsMapper.getUUID(new HashMap<String,Object>(){{
                    put("uuid", "PaId");
                    put("database", Constants.DATA_SOURCE_TCMKT);
                    put("surface", "tcmkt_pact");
                }});
                if(uuid!=null){
                    int number=Integer.valueOf(uuid.get("uuid").toString());
                    UUID= ComUtils.getLocalTrmSeqNum("pt",number);
                }else{
                    UUID=ComUtils.getLocalTrmSeqNum("pt",0);
                }
                params.put("by", "auto");//操作人
                params.put("PaId",UUID);
                params.put("IfAudit",0);//是否要审核（0 否 1 是）
                params.put("term", "1");// 创建端 Insert端： 1 租客端 2市场部 3 工程部   4运营部   5财务部  6总经办 7发展部
                params.put("fnc",
                        this.getClass().getSimpleName() + "." + Thread.currentThread().getStackTrace()[1].getMethodName());// 创建Function名
                ParamsCommon.commonInsertParms(params);
                if (!params.get("ifPactMethod").toString().equals("0")){ //如果有合租人的话
                    List<Map<String,Object>> shareList=new ArrayList<Map<String,Object>>();
                    if (params.get("ifPactMethod").toString().equals("1")){//0无合租人 1合租人不变 2新合租人
                        //查询原合同的合租人信息
                        shareList=rdPactSharedMapper.getWxPactSharedList(params);

                    }else if (params.get("ifPactMethod").toString().equals("2")){//新合租人
                        shareList=(List<Map<String,Object>>)params.get("shareList");
                    }
                    if (shareList!=null){//如果原合同有合租人
                        for (int i=0;i<shareList.size();i++){
                            Map<String,Object> shareMap=shareList.get(i);
                            shareMap.put(" ",UUID);//合同编号
                            shareMap.put("instm",params.get("instm"));
                            shareMap.put("insterm",params.get("insterm"));
                            shareMap.put("insby",params.get("insby"));
                            shareMap.put("insfnc",params.get("insfnc"));
                            rdPactSharedMapper.addPactShared(shareMap);
                        }
                    }
                }
                params.put("id",params.get("PaId"));
                log.info("params======================="+params.get("id"));
                log.info("params======================="+params.get("TenId"));




                //////////////////////////////////////////////////
                //生成电子合同必传参数
                /////////////////////////////////////////////////
                params.put("HTbianhao",params.get("PaId"));//合同编号
                params.put("HTjiafang","上海唐巢公共租赁住房运营有限公司");//出租方甲方
                //params.put("HTyifang",);//承租方乙方
                // params.put("HTdizhi",);//房屋地址
                // params.put("HTzulinqixian",);//租赁期限
                params.put("HTqishiriqi",params.get("StartTime"));//起始日期
                params.put("HTjiezhiriqi",params.get("EndTime"));//终止日期
                params.put("HTzujin",params.get("PaRearMonthPrice"));//房屋月租金
                params.put("HTzujindaxie",TransFormUtil.toChinese(params.get("PaRearMonthPrice").toString()));//月租金大写
                Integer PmthendInt = MapUtils.getInteger(params,"Pmethod");
                if (PmthendInt==0){//月付
                    params.put("HTfu",1);//支付方式付
                }else if(PmthendInt==1){//季付
                    params.put("HTfu",3);//支付方式付
                }else if(PmthendInt==2){//半年付
                    params.put("HTfu",6);//支付方式付
                }else if(PmthendInt==3){//年付
                    params.put("HTfu",12);//支付方式付
                }
                params.put("HTya",params.get("Deposit"));//支付方式押
                params.put("HTyayue",params.get("Deposit"));//租赁押金月
                Integer PaInteger = MapUtils.getInteger(params,"PaMonthPrice")* MapUtils.getInteger(params,"Deposit");
                params.put("HTtongyidingjia",PaInteger);//人民币
                params.put("HTtongyidingjiadaxie",TransFormUtil.toChinese(String.valueOf(PaInteger)));//人民币大写
                params.put("HTdianfei",params.get("EleFee").toString()+"元/度");//电费
//                params.put("HTshuifei",);//水费
//                params.put("HTranqi",);//燃气费
                params.put("HTkuandai",params.get("BroadBand"));//宽带费
                params.put("HTdianshi",0);//有限电视
                params.put("HTqita",0);//其他
                params.put("HTchuzufangjiafang","上海唐巢公共租赁住房运营有限公司");//出租房（甲方)
                //   params.put("HTdailirenjiafang","上海唐巢公共租赁住房运营有限公司");//甲方代理人
                params.put("HTqianyueriqijiafang",orderDate);//甲方签约日期
                //params.put("HTshenfengzhengyifang",);//乙方身份证
                // params.put("HTlianxidizhiyifang",);//乙方联系地址
                // params.put("HTlianxidianhuayifang",);//乙方联系电话
                // params.put("HTjinjilianxirenyifang",);//乙方紧急联系人电话
                params.put("HTqianyueriqiyifang",orderDate);//乙方签约日期


                log.info("生成电子合同前查询参数111111111111111111111");
                log.info("params"+params);
                log.info("生成电子合同前查询参数111111111111111111111");


                //调用生成续签电子合同的方法
                JsonResult resultTen=signedProviderService.createRenewPact(params);
                System.out.println("resultTen续签合同模板返回信息:"+resultTen);
                if(resultTen.get("errorCode").toString().equals("0")){//返回电子合同模板
                    //调用生成账单
//                    Map<String,Object> gmioMap=new HashMap<String,Object>();
//                    gmioMap.put("WaDeposit",params.get("WaDeposit"));
//                    gmioMap.put("HouId",params.get("HouId"));
//                    gmioMap.put("HouInfoId",params.get("HouInfoId"));
//                    gmioMap.put("TenId",params.get("TenId"));
//                    gmioMap.put("payYa",params.get("payYa"));
//                    gmioMap.put("Pmethod",params.get("Pmethod"));
//                    gmioMap.put("PaId",params.get("PaId"));
//                    gmioMap.put("bottomADate",params.get("bottomADate"));
//                    gmioMap.put("monthMoney",params.get("newTotalMoney"));
//                    gmioMap.put("CorId",params.get("CorId"));
//                    gmioMap.put("payFu",params.get("payFu"));
//                    JsonResult gmioResult=zpcGmioFeign.addTenantBillForPact(gmioMap);
//                    System.out.println("返回参数运营部:"+gmioResult);
//                    if (!gmioResult.get("errorCode").toString().equals("0")){
//                        TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
//                        return result.putFailed("服务器繁忙");
//                    }
                    params.put("actualDeposit",String.valueOf(actualDeposit));//房屋押金
                    params.put("MoviesType",String.valueOf(params.get("MoviesType")));
                    params.put("IsWater",String.valueOf(params.get("IsWater")));
                    params.put("IsGas",String.valueOf(params.get("IsGas")));
                    Map<String,Object> tenMap=(Map<String,Object>)resultTen.get("result");
                    params.putAll(tenMap);//把电子合同的信息保存到合同表
                    params.put("MoviesVal",params.get("MoviesVal0"));//电表读数
                    System.out.println("新增到数据库中的参数:"+params);
                    rdPactMapper.addPact(params);//新增合同
                    pactMap.put("by", "auto");//操作人
                    pactMap.put("NextPaId",UUID);
                    pactMap.put("IfAudit",0);//是否要审核（0 否 1 是）
                    pactMap.put("term", "1");// 创建端 Insert端： 1 租客端 2市场部 3 工程部   4运营部   5财务部  6总经办 7发展部
                    pactMap.put("fnc",
                            this.getClass().getSimpleName() + "." + Thread.currentThread().getStackTrace()[1].getMethodName());// 创建Function名
                    ParamsCommon.commonInsertParms(pactMap);
                    System.out.println("pactMap:"+pactMap);
                    Integer pactCount=rdPactMapper.updatePact(pactMap);//修改原合同编号
                    System.out.println("pactCount ==null || pactCount<1:"+pactCount ==null || pactCount<1);
                    if (pactCount ==null || pactCount<1){
                        return  result.putFailed("服务器繁忙");
                    }else{
                        System.out.println("!");
                        result=resultTen;
                    }
                    //推送微信模板
//                    String touser=params.get("openid").toString();//租客的openid
//                    String templateId= WeChatConfig.TEMPLATE_ID;//维修推送模板id(提醒用户签约)
//                    Map<String, TemplateData> param = new HashMap<>();params.get("bottomA").toString();
//                    param.put("first", new TemplateData("唐巢公寓温馨提示：尊敬的租客，您与我司签的续签租赁合同已签约成功。请您确认信息是否正确？如有异议，请联系您的租赁顾问人员为您服务。\n", "#4876FF"));
//                    param.put("keyword1", new TemplateData(params.get("payYaMoney").toString()+"元", "#4876FF"));
//                    param.put("keyword2", new TemplateData(params.get("payFu")+"个月", "#4876FF"));
//                    param.put("keyword3", new TemplateData("支付方式：付" +params.get("payFu")+"押"+params.get("payYa"), "#4876FF"));
//                    param.put("keyword4", new TemplateData("月付", "#4876FF"));
//                    Jsapi_ticketUtil.sendTemplate(touser,templateId,"http://www.4006269069.net/#/staySigning?pactId="+params.get("PaId"),"#4876FF", JSONObject.fromObject(param));

                }else{//如果电子合同返回的状态码异常就不去新增合同主表
                    result.putFailed("合同模板创建异常");
                }
            } catch (Exception e) {
                e.printStackTrace();
                TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
                result.putFailed("服务器繁忙");
            }
        }
        finally {
            lock.unlock();
        }
        return result;
    }
    /**
     * 根据租客编号查询租客的历史签约条数
     */
    public JsonResult getPactCountByTenId(Map<String,Object> params){
        JsonResult result=new JsonResult();
        if (params.get("TenId")==null){
            return result.putFailed("参数不正确");
        }
        Integer count=rdPactMapper.getPactCountByTenId(params);
        if (count!=null){
            result.put(count);
        }else{
            result.putFailed("服务器繁忙");
        }
        return result;
    }
    /**
     *运营部服务管家退租验收、延期申请、退租申请、强制退申请
     */
    public List<Map<String,Object>> getHouPactApplyList(Map<String,Object> params){
        return rdPactMapper.getHouPactApplyList(params);
    }
    /**
     * 房源退租修改合同
     */
    @Transactional(rollbackFor = Exception.class)
    public JsonResult updatePactRent(Map<String,Object> params){
        JsonResult result=new JsonResult();
        /**
         * 加锁操作
         */
        lock.lock();
        try{
            try {
                if (params.get("ProOperaType")==null || params.get("HouId")==null || params.get("HouInfoId")==null
                        || params.get("PaId")==null ||params.get("DelIdList")==null){
                    return result.putFailed("参数不正确");
                }
                params.put("by", ContextUtils.getUserId());//操作人
                params.put("term", "4");// 创建端 Insert端： 1 租客端 2市场部 3 工程部   4运营部   5财务部  6总经办 7发展部
                params.put("fnc",
                        this.getClass().getSimpleName() + "." + Thread.currentThread().getStackTrace()[1].getMethodName());// 创建Function名
                ParamsCommon.commonInsertParms(params);
                params.put("Status",1);//0 履约中 1已退租 2转租成功
                Integer count=rdPactMapper.updatePactRent(params);
                params.put("PaId","");//把房源详表的合同编号清空
                params.put("State",0);//0 待上架 1可签约 2已签约
                //ProOperaType 房源租赁类型 1.合租 2.整租
                if (params.get("ProOperaType").toString().equals("1")){
                    params.put("ifHouInfoId","1");
                }else if (params.get("ProOperaType").toString().equals("2")){
                    params.put("ifHouId","1");
                }
                Integer count2=rdHousingInfoMapper.updateHousingStateHouInfo(params);
                //修改智能门锁key为废弃
                params.put("delfg","1");//废弃标志位 0正常 1废弃
                List<Map<String,Object>> lockList=(List<Map<String,Object>>)params.get("DelIdList");
                System.out.println("lockList:"+lockList);
                Integer count3=rdHousingSmartMapper.updateRdHouSmart(params);
                if (count>0 && count2>0 && count3==lockList.size()){
                    result.put("操作成功");
                }else{
                    result.putFailed("服务器繁忙");
                }
            } catch (Exception e) {
                e.printStackTrace();
                TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
            }
        }
        finally {
            lock.unlock();
        }
        return result;
    }
    /**
     * 换房修改原合同
     */
    @Transactional(rollbackFor = Exception.class)
    public JsonResult updatePactTrade(Map<String,Object> params){
        JsonResult result=new JsonResult();
        /**
         * 加锁操作
         */
        lock.lock();
        try{
            try {
                if (params.get("TradeId")==null || params.get("PaId")==null){
                    return result.putFailed("参数不正确");
                }
                params.put("by", ContextUtils.getUserId());//操作人
                params.put("term", "2");// 创建端 Insert端： 1 租客端 2市场部 3 工程部   4运营部   5财务部  6总经办 7发展部
                params.put("fnc",
                        this.getClass().getSimpleName() + "." + Thread.currentThread().getStackTrace()[1].getMethodName());// 创建Function名
                ParamsCommon.commonInsertParms(params);
                Integer count=rdPactMapper.updatePactTrade(params);
                if (count>0){
                    result.put("操作成功");
                }else{
                    result.putFailed("服务器繁忙");
                }
            } catch (Exception e) {
                e.printStackTrace();
                TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
            }
        }
        finally {
            lock.unlock();
        }
        return result;
    }
    /**
     *查询合同的换房信息、转租信息
     */
    public JsonResult getRdPactTrade(Map<String,Object> params){
        JsonResult result=new JsonResult();
        List<Map<String,Object>> list=rdPactMapper.getRdPactTrade(params);
        if (list!=null){
            result.put(list);
        }else{
            result.putFailed("服务器繁忙");
        }
        return result;
    }
    /**
     * 查询当前房源履约中的各个房间的租客
     */
    public JsonResult getRdPactTenList(Map<String,Object> params){
        JsonResult result=new JsonResult();
        if (params.get("HouId")==null){
            return result.putFailed("参数不正确");
        }
        List<Map<String,Object>> list=rdPactMapper.getRdPactTenList(params);
        if (list!=null){
            result.put(list);
        }else{
            result.putFailed("服务器繁忙");
        }
        return result;
    }
    /**
     * 租客端协助开门查询手机号是否该租客的室友
     */
    public JsonResult getRdPactTenPhoneCount(Map<String,Object> params){
        JsonResult result=new JsonResult();
        if (params.get("TenId")==null || params.get("TenMode")==null){
            return result.putFailed("参数不正确");
        }
        Integer count=rdPactMapper.getRdPactTenPhoneCount(params);
        System.out.println("count:"+count);
        if (count!=null){
            result.put(count);
        }else{
            result.putFailed("服务器繁忙");
        }
        return result;
    }
    /**
     * 协助开门 查询当前租客所签房源列表
     */
    public JsonResult getRdInteHouList(Map<String,Object> params){
        JsonResult result=new JsonResult();
        if (params.get("TenId")==null || params.get("TenIdB")==null){
            return result.putFailed("参数不正确");
        }
        //查询房源的列表
        List<Map<String,Object>> houList=rdPactMapper.getRdInteHouList(params);
        List<String> houIdList=new ArrayList<String>();//保存房源的编号
        List<String> houInfoIdList=new ArrayList<String>();//保存房间的编号
        for (Map<String,Object> map: houList){
            System.out.println("ProOperaType:"+map.get("ProOperaType"));
            if (map.get("ProOperaType")!=null && map.get("ProOperaType").toString().equals("2")){
                if(map.get("HouId")!=null){
                    houIdList.add(map.get("HouId").toString());
                }
            }else if(map.get("ProOperaType")!=null && map.get("ProOperaType").toString().equals("1")){
                houInfoIdList.add(map.get("HouId").toString());
            }

        }
        params.put("houIdList",houIdList);
        params.put("houInfoIdList",houInfoIdList);
        System.out.println("houIdList:"+houIdList);
        System.out.println("houInfoIdList:"+houInfoIdList);
        //查询房源的房间列表
        List<Map<String,Object>> houConListList=rdPactMapper.getRdInteHouConList(params);
        for (Map<String,Object> map1:houList) {
            List<Map<String, Object>> list = new ArrayList<Map<String, Object>>();
            if (map1.get("HouId") != null) {
                for (Map<String, Object> map2 : houConListList) {
                    if (map2.get("HouId") != null) {
                        if (map1.get("HouId").toString().equals(map2.get("HouId").toString())) {
                            list.add(map2);
                        }
                    }
                }
            }
            map1.put("houConListList",list);
        }
        return  result.put(houList);
    }
    /**
     * 申请临时密码 查询该租客的房源信息列表
     */
    public JsonResult getRdTemInteHouConList(Map<String,Object> params){
        JsonResult result=new JsonResult();
        if (params.get("TenId")==null){
            return result.putFailed("参数不正确");
        }
        List<Map<String,Object>> houList=rdPactMapper.getRdTemInteHouConList(params);//查询房源的列表
        System.out.println("houList:"+houList);
        List<String> houIdList=new ArrayList<String>();  //房源详表编号的数组
        List<String> houInfoIdList=new ArrayList<String>();
        List<String> houInfoPubIdList=new ArrayList<String>();//保存公共区域编号
        for (Map<String,Object> map: houList){
            System.out.println("ProOperaType:"+map.get("ProOperaType"));
            if (map.get("ProOperaType")!=null && map.get("ProOperaType").toString().equals("2")){
                if(map.get("HouId")!=null){
                    houIdList.add(map.get("HouId").toString());
                }
            }else if(map.get("ProOperaType")!=null && map.get("ProOperaType").toString().equals("1")){
                houInfoIdList.add(map.get("HouInfoId").toString());
                houInfoPubIdList.add(map.get("HouId").toString());
            }
        }
        params.put("houIdList",houIdList);
        params.put("houInfoIdList",houInfoIdList);
        params.put("houInfoPubIdList",houInfoPubIdList);
        //查询房源的房间列表
        List<Map<String,Object>> houConList=rdPactMapper.getRdTemInteHouConInfoList(params);
        //房间编号的数组
        List<String> houConIdList=new ArrayList<String>();
        for (Map<String,Object> map: houConList){
            if(map.get("HouConId")!=null){
                houConIdList.add(map.get("HouConId").toString());
            }
        }
        params.put("houConIdList",houConIdList);
        System.out.println("市场部传递的参数:"+params);
        //查询房源的房间列表
        JsonResult zpcResult=zpcEpcFeign.getHoRdHouList(params);
        System.out.println("工程部查询的:"+zpcResult);
        if (zpcResult.get("errorCode").toString().equals("0")){
            List<Map<String,Object>> zpcList=(List<Map<String,Object>>)zpcResult.get("result");
            for (Map<String,Object> map1:houList){
                List<Map<String, Object>> list = new ArrayList<Map<String, Object>>();
                if (map1.get("HouId")!=null){
                    for (Map<String,Object> map2:zpcList){
                        if (map2.get("HouId")!=null){
                            if (map1.get("HouId").toString().equals(map2.get("HouId").toString())){
                                list.add(map2);
                            }
                        }
                    }
                }
                map1.put("houConListList",list);
            }
        }
        return  result.put(houList);
    }
    /**
     *智能设备充值 查询租客所租的智能设备房间
     */
    public JsonResult getRdInteDeviceHouConList(Map<String,Object> params){
        JsonResult result=new JsonResult();
        if (params.get("TenId")==null){
            return result.putFailed("参数不正确");
        }
        //查询房源的列表
        List<Map<String,Object>> houList=rdPactMapper.getRdTemInteHouConList(params);
        //房间编号的数组
        List<String> houConIdList=new ArrayList<String>();
        for (Map<String,Object> map: houList){
            if(map.get("HouConId")!=null){
                houConIdList.add(map.get("HouConId").toString());
            }
        }
        params.put("houConIdList",houConIdList);
        System.out.println("市场部传递的参数:"+params);
        //查询房源的房间列表
        JsonResult zpcResult=zpcEpcFeign.getHoRdInteDeviceHouList(params);
        System.out.println("工程部查询的:"+zpcResult);
        if (zpcResult.get("errorCode").toString().equals("0")){
            List<Map<String,Object>> zpcList=(List<Map<String,Object>>)zpcResult.get("result");
            for (Map<String,Object> map1:houList){
                List<Map<String, Object>> list = new ArrayList<Map<String, Object>>();
                if (map1.get("HouId")!=null){
                    for (Map<String,Object> map2:zpcList){
                        if (map2.get("HouId")!=null){
                            if (map1.get("HouId").toString().equals(map2.get("HouId").toString())){
                                list.add(map2);
                            }
                        }
                    }
                }
                map1.put("houConListList",list);
                List<Map<String,Object>> houConListListss = (List<Map<String, Object>>) map1.get("houConListList");//
                for (Map<String,Object> ceshiMap:houConListListss){
                     JsonResult epcResult = epcFeign.getHoRdInteDeviceConList(ceshiMap);
                     Map<String,Object> epcMap = (Map<String, Object>) epcResult.get("result");
                     ceshiMap.putAll(epcMap);

                    // 0.蜂电   1.大华   2.科技侠   3.果加
                    if (ceshiMap.get("Intelligent").toString().equals("0")){
                        String InteDeviceBeeToken=redisUtils.get("InteDeviceBeeToken");
                        //如果获取不到就重新登录
                        if (InteDeviceBeeToken==null) {
                            Map<String, Object> tokenMap = new HashMap<String, Object>();
                            params.put("version","0116010101");//版本号 默认 0116010101
                            params.put("appid", InteDeviceBeeConfig.APP_ID);
                            tokenMap= InteDeviceBeeUtil.userLogin(InteDeviceBeeConfig.USERID, InteDeviceBeeConfig.PASS,params);
                            if (tokenMap.get("Code").toString().equals("0")) {
                                InteDeviceBeeToken = tokenMap.get("Expand").toString();
                                //token存到redis中 有效时长一个小时
                                redisUtils.set("InteDeviceBeeToken", InteDeviceBeeToken,3600);
                            } else {
                                return result.putFailed("token获取失败");
                            }
                        }

                        //获取单个单表（为了获取到智能设备的设备UUID）
                        Map<String,Object> pcodeParams=new HashMap<String, Object>();
                        pcodeParams.put("uid",InteDeviceBeeConfig.UID);
                        pcodeParams.put("token",InteDeviceBeeToken);
                        pcodeParams.put("version", "0116010101");//版本号默认0116010101

                        Map<String,Object> inteBeeMap=InteDeviceBeeUtil.deviceAmmeter(ceshiMap.get("Identifier").toString(),pcodeParams);
                        if (inteBeeMap.get("Code").toString().equals("0")) {
                            List<Map<String, Object>> dataList = (List<Map<String, Object>>) inteBeeMap.get("Data");
                            ceshiMap.put("Uuid", dataList.get(0).get("Uuid"));
                            ceshiMap.put("Price", dataList.get(0).get("Price"));
                            Double surplus = MapUtils.getDouble((Map<String,Object>)dataList.get(0).get("Expand"),"surplus");
                            ceshiMap.put("SmartBalance",CompuUtils.mul(MapUtils.getDouble(ceshiMap,"Price"),surplus));

                        }else{
                            return result.put("蜂电服务器异常");
                        }
                    }else if(ceshiMap.get("Intelligent").toString().equals("1")){//大华

                        String InteDaHuaToken = redisUtils.get("InteDaHuaToken");
                        //如果获取不到就重新登录
                        if (InteDaHuaToken == null) {
                            /*获取token*/
                            Map<String, Object> DaParams = new HashMap<String, Object>();
                            DaParams.put("pw", InteDeviceDaHuaConfig.PW);
                            DaParams.put("userName", InteDeviceDaHuaConfig.USERNAME);
                            DaParams = InteDeviceDaHuaUtil.getToken(DaParams);
                            if (DaParams.get("code") != null && DaParams.get("code").toString().equals("1")) {//1 状态码 请求成功
                                InteDaHuaToken = DaParams.get("data").toString();
                                //token有效期2个小时，所有接口Code=0 ，token失效 需要重新获取
                                redisUtils.set("InteDaHuaToken", InteDaHuaToken, 3600 * 2);
                                System.out.println(InteDaHuaToken);
                            } else {
                                return result.putFailed("token获取失败");
                            }
                        }

                        Map<String, Object> tokenMap = new HashMap<>();
                        tokenMap.put("token", InteDaHuaToken);
                        tokenMap.put("meter_id", ceshiMap.get("Identifier"));
                        Map<String,Object> payAmountByIdMap = InteDeviceDaHuaUtil.getRemainById(tokenMap);

                        log.info("11111111111111");
                        log.info("测试");
                        System.out.println(tokenMap);
                        System.out.println("11111111111111"+payAmountByIdMap);
                        if (!(payAmountByIdMap.get("code") != null && payAmountByIdMap.get("code").toString().equals("1"))) {//0 状态码 请求成功
                            return result.putFailed("查询大华智能设备失败");
                        }else{
                            ceshiMap.put("SmartBalance",CompuUtils.mul(MapUtils.getDouble(payAmountByIdMap,"data"),MapUtils.getDouble(payAmountByIdMap,"price")));
                        }
                    }
                }

            }
        }
        return  result.put(houList);
    }
    /**
     *智能设备充值 查询租客所租的房子智能设备余额的和
     */
    public JsonResult getRdCensusHouConList(Map<String,Object> params){
        JsonResult result=new JsonResult();
        Map<String,Object> resultMap=new HashMap<String,Object>();
        BigDecimal eleMoneySum=new BigDecimal("0");//智能电表总余额
        BigDecimal eleMoneyBee=new BigDecimal("0");//蜂电智能电表余额
        BigDecimal eleMoneyDaHua=new BigDecimal("0");//智能电表总余额
        //保存所有与收费标准关联的编号
        HashSet<Object> conList=new HashSet<Object>();
        if (params.get("TenId")==null){
            return result.putFailed("参数不正确");
        }
        //查询租客居住中的房源编号列表
        List<Map<String,Object>> list=rdPactMapper.getRdCensusHouConList(params);

        List<String> houConIdList=new ArrayList<String>();
        for (Map<String,Object> map: list){
            if(map.get("HouConId")!=null){
                houConIdList.add(map.get("HouConId").toString());
            }
            //收费标准关联编号
            if (map.get("HouId")!=null){
                conList.add(map.get("HouId"));
            }
            if (map.get("ComId")!=null){
                conList.add(map.get("ComId"));
            }
            if (map.get("CorId")!=null){
                conList.add(map.get("CorId"));
            }
            if (map.get("MiId")!=null){
                conList.add(map.get("MiId"));
            }
        }
        params.put("houConIdList",houConIdList);
        params.put("conList",conList);
        //查询收费标准的集合
        JsonResult gmioResult=zpcGmioFeign.getRdChargesDeptList(params);
        List<Map<String,Object>> gmioList=(List<Map<String,Object>>)gmioResult.get("result");
        if (gmioResult.get("errorCode").toString().equals("0")) {
            for (Map<String, Object> giomap : gmioList) {
                for (Map<String, Object> mktmap : list) {
                    if (MapUtils.getString(giomap, "ContactId").equals(MapUtils.getString(mktmap, "HouId"))) {
                        mktmap.putAll(giomap);
                        continue;
                    } else if (MapUtils.getString(giomap, "ContactId").equals(MapUtils.getString(mktmap, "ComId"))) {
                        mktmap.putAll(giomap);
                        continue;
                    } else if (MapUtils.getString(giomap, "ContactId").equals(MapUtils.getString(mktmap, "MiId"))) {
                        mktmap.putAll(giomap);
                        continue;
                    } else if (MapUtils.getString(giomap, "ContactId").equals(MapUtils.getString(mktmap, "CorId"))) {
                        mktmap.putAll(giomap);
                        continue;
                    }
                }
            }
        }
        System.out.println("匹配过收费标准后:"+list);
        //查询房间的智能设备编号集合
        JsonResult zpcResult=zpcEpcFeign.getHoRdCensusInteDeviceList(params);
        //保存蜂电的智能设备编号集合
        List<String> beeIdList=new ArrayList<String>();
        //保存大华的智能设备编号
        List<String> daHuaList=new ArrayList<String>();
        if (zpcResult.get("errorCode").toString().equals("0")){
            //智能电表编号的集合
            List<Map<String,Object>> inteIdList=(List<Map<String,Object>>)zpcResult.get("result");
            System.out.println("inteIdList"+inteIdList);
            for (Map<String,Object> inteMap:inteIdList){
                //智能设备供应商     0.蜂电   1.大华   2.科技侠   3.果加
                if (inteMap.get("Identifier")!=null && inteMap.get("Intelligent").toString().equals("0")){
                    beeIdList.add(inteMap.get("Identifier").toString());
                }else if (inteMap.get("Identifier")!=null && inteMap.get("Intelligent").toString().equals("1")){
                    daHuaList.add(inteMap.get("Identifier").toString());
                }
                for (Map<String,Object> inteMap2:list){
                    if (inteMap.get("HouConId").toString().equals(inteMap2.get("HouConId"))){
                        inteMap2.putAll(inteMap);
                    }
                }
            }
            System.out.println("list匹配智能设备之后的集合:"+list);
            System.out.println("beeIdList:"+beeIdList);
            System.out.println("zpcResult:"+zpcResult);
            //当蜂电的智能电表编号集合长度不为零的时候 计算蜂电智能电表余额
            if (beeIdList.size()>0){
                String InteDeviceBeeToken=redisUtils.get("InteDeviceBeeToken");
                //如果获取不到就重新登录
                if (InteDeviceBeeToken==null) {
                    Map<String, Object> tokenMap = new HashMap<String, Object>();
                    tokenMap.put("version","0116010101");//版本号 默认 0116010101
                    tokenMap.put("appid",InteDeviceBeeConfig.APP_ID);
                    tokenMap=InteDeviceBeeUtil.userLogin(InteDeviceBeeConfig.USERID, InteDeviceBeeConfig.PASS,tokenMap);
                    if (tokenMap.get("Code").toString().equals("0")) {
                        InteDeviceBeeToken = tokenMap.get("Expand").toString();
                        //token存到redis中 有效时长一个小时
                        redisUtils.set("InteDeviceBeeToken", InteDeviceBeeToken,3600);
                    } else {
                        return result.putFailed("token获取失败");
                    }
                }
                //蜂电请求必填的head参数
                Map<String,Object> headMap=new HashMap<String, Object>();
                headMap.put("uid",InteDeviceBeeConfig.UID);
                headMap.put("token",InteDeviceBeeToken);
                //查询多个电表的数据
                Map<String,Object> InteDataMap=InteDeviceBeeUtil.deviceAmmeterPcode(beeIdList,headMap);
                if (InteDataMap.get("Code").toString().equals("0")) {// 0蜂电接口返回正常
                    //电表数组
                    List<Map<String,Object>> InteDataList=(List<Map<String,Object>>)InteDataMap.get("Data");
                    System.out.println("InteDataList:"+InteDataList);
                    System.out.println("list:"+list);
                    for (Map<String,Object> map1:InteDataList){
                        for (Map<String,Object> map2:list){
                            if (map1.get("Pcode").toString().equals(map2.get("Identifier"))){
                                if (map1.get("Expand")!=null){
                                    Map<String,Object>aMap=(Map<String,Object>)map1.get("Expand");
                                    //蜂电余额+=电表剩余可用电量*收费标准
//                                    eleMoneyBee+=Double.parseDouble(aMap.get("surplus").toString())
//                                            *Double.parseDouble(map2.get("EleFee").toString());
                                    eleMoneyBee=eleMoneyBee.add(new BigDecimal(aMap.get("surplus").toString()).multiply(new BigDecimal(map2.get("EleFee").toString())));
                                    System.out.println("电表读数："+Double.parseDouble(aMap.get("surplus").toString()));
                                    System.out.println("电费收费标准："+Double.parseDouble(map2.get("EleFee").toString()));
                                }
                            }
                        }

                    }
                }
            }
            if (daHuaList.size()>0){
                String InteDaHuaToken=redisUtils.get("InteDaHuaToken");
                //如果获取不到就重新登录
                if (InteDaHuaToken==null){
                    /*获取token*/
                    Map<String,Object> DaParams=new HashMap<String, Object>();
                    DaParams.put("pw",InteDeviceDaHuaConfig.PW);
                    DaParams.put("userName",InteDeviceDaHuaConfig.USERNAME);
                    DaParams=InteDeviceDaHuaUtil.getToken(DaParams);
                    if (DaParams.get("code")!=null && DaParams .get("code").toString().equals("1")){//1 状态码 请求成功
                        InteDaHuaToken=DaParams.get("data").toString();
                        //token有效期2个小时，所有接口Code=0 ，token失效 需要重新获取
                        redisUtils.set("InteDaHuaToken",InteDaHuaToken,3600*2);
                    }else{
                        return result.putFailed("token获取失败");
                    }
                }
                Map<String,Object> getParams=new HashMap<String,Object>();
                getParams.put("token",InteDaHuaToken);//访问token
                getParams.put("level1", StringUtils.join(daHuaList.toArray(), ","));//逗号隔开的字符串
                //查询智能设备的电表读数
                getParams=InteDeviceDaHuaUtil.getAllRemainByLevel1(getParams);
                if (getParams.get("code")!=null && getParams .get("code").toString().equals("1")) {//0 状态码 请求成功
                    BigDecimal price=new BigDecimal("0");//保存大华的电表单价
                    BigDecimal sumMoney=new BigDecimal("0");//保存大华的电表余额
                    //电表数组
                    List<Map<String,Object>> dataList=(List<Map<String,Object>>)getParams.get("data");
                    System.out.println("dataList:"+dataList);
                    for (Map<String,Object> map1:dataList){
                        if (map1.get("price")!=null){
                            price=new BigDecimal(map1.get("price").toString());
                        }
                        for (Map<String,Object> map2:list){
                            if (map1.get("meter_id").toString().equals(map2.get("Identifier"))){
                                if (map1.get("data")!=null){
                                    //大华余额=大华余额+大华可用电量*大华电费单价/内部系统电费定价
                                    eleMoneyDaHua=eleMoneyDaHua.add(new BigDecimal(map1.get("data").toString()).multiply(price).divide(new BigDecimal(map2.get("EleFee").toString()),2));
                                    System.out.println("电表读数："+Double.parseDouble(map1.get("data").toString()));
                                    System.out.println("电费收费标准："+Double.parseDouble(map2.get("EleFee").toString()));
                                }
                            }
                        }

                    }
                }else{
                    return result.putFailed("第三方服务器繁忙");
                }
            }
            System.out.println("eleMoneyBee:"+eleMoneyBee);
            System.out.println("eleMoneyDaHua:"+eleMoneyDaHua);
            eleMoneySum=eleMoneyBee.add(eleMoneyDaHua);
            resultMap.put("eleMoneySum",eleMoneySum);
        }else{
            return zpcResult;
        }
        return result.put(resultMap);
    }
    /**
     *续签合同的时候查询合同的信息
     */
    public JsonResult getRdRenPactInfo(Map<String,Object> params){
        JsonResult result=new JsonResult();
        Map<String,Object> map=rdPactMapper.getRdRenPactInfo(params);
        if (map!=null){
            result.put(map);
        }else{
            result.putFailed("服务器繁忙");
        }
        return result;
    }
    /**
     * 租客端续签合同时 房屋账单支付完成后修改合同信息
     */
    public JsonResult updatePactByRent(Map<String,Object> params){
        JsonResult result=new JsonResult();

        //组装修改合同的参数
        Map<String,Object> pactMap=new HashMap<String,Object>();
        //水电押金   支付状态   0不需要支付   1.待支付   2支付完成    3待审核
        pactMap.put("IfFlowPay", "2");//电子合同是否支付     0无状态   1已完成未支付   \n2已完成已支付
        pactMap.put("Hydropower","2");//水电押金//支付完成 续签不需要支付水电押金
        pactMap.put("PaId",params.get("PaId"));//合同编号
        pactMap.put("RentStatus","2");//房租/押金     支付状态   0不需要支付   1.待支付   2支付完成
        pactMap.put("by", "auto");//操作人
        pactMap.put("term", "1");// 创建端 Insert端： 1 租客端 2市场部 3 工程部   4运营部   5财务部  6总经办 7发展部
        pactMap.put("fnc",
                this.getClass().getSimpleName() + "." + Thread.currentThread().getStackTrace()[1].getMethodName());// 创建Function名
        ParamsCommon.commonInsertParms(pactMap);
        if (rdPactMapper.updatePactForSeXu(pactMap)>0){
            result.putSuccess("操作成功");
        }else{
            result.putFailed("服务器繁忙");
        }
        return result;
    }
    /**
     *租后主管的租客管理查询续租租客列表
     */
    public List<Map<String,Object>> getRdRenewalTenList(Map<String,Object> params){
        return  rdPactMapper.getRdRenewalTenList(params);
    }
    /**
     *租后主管的租客管理查询续租租客列表总数
     */
    public Integer getRdRenewalTenListCount(Map<String,Object> params){
        return  rdPactMapper.getRdRenewalTenListCount(params);
    }
    /**
     *租后主管查询常规退或是违约退（查询房源的相关信息）
     */
    public JsonResult getRdRenewalTenInfoList(Map<String,Object> params){
        JsonResult result=new JsonResult();
        List<Map<String,Object>> list=rdPactMapper.getRdRenewalTenInfoList(params);
        if (list!=null){
            result.put(list);
            System.out.println(result);
        }else{
            result.putFailed("服务器繁忙");
        }
        return result;
    }
    /**
     *租客端续签的时候查询房源是否发起过续签
     */
    public JsonResult getRdRenPactData(Map<String,Object> params){
        JsonResult result=new JsonResult();
        if (params.get("PaId")==null){
            return result.putFailed("参数不正确");
        }
        Map<String,Object> map=rdPactMapper.getRdRenPactData(params);
        if (map!=null){
            result.put(map);
        }else{
            result.putFailed("服务器繁忙");
        }
        return result;
    }

}
